|
|
To install Fortran on your system, you can follow these general steps:
Setting up an IDE for Fortran can enhance your development experience. Here's how to do it:
Here's a basic Fortran program that prints "Hello, World!" to the console:
program hello
print *, "Hello, World!"
end program hello
Following best practices can lead to cleaner, more maintainable Fortran code:
Fortran supports OOP features through modules and derived types. Here's an example:
module shapes
type :: Shape
real :: area
end type Shape
type, extends(Shape) :: Circle
real :: radius
end type Circle
type, extends(Shape) :: Rectangle
real :: length, width
end type Rectangle
end module shapes
In this example, we define a module shapes containing base type Shape and derived types Circle and Rectangle.
Fortran provides several methods for parallel programming, including:
Here's an example of using OpenMP:
program parallel_hello
implicit none
integer :: i, tid, num_threads
!$OMP PARALLEL PRIVATE(tid)
tid = omp_get_thread_num()
num_threads = omp_get_num_threads()
print *, 'Hello from thread', tid, 'of', num_threads
!$OMP END PARALLEL
end program parallel_hello
This program prints a message from each parallel thread.
Fortran (Formula Translation) is a high-level programming language mainly used for numerical and scientific computing. It was first developed in the 1950s and has undergone several revisions since then, with the latest standard being Fortran 2018. Fortran is known for its efficiency in handling numerical computations and is widely used in fields such as engineering, physics, weather forecasting, and computational chemistry.
Fortran offers several features that make it suitable for scientific and numerical computing:
Here's a basic "Hello, World!" program written in Fortran:
program hello
print *, "Hello, World!"
end program hello
This program simply prints "Hello, World!" to the standard output.
Fortran syntax follows a column-based format. Each line of code is divided into specific columns, with certain columns reserved for specific purposes:
Fortran statements are generally terminated with a newline character.
A typical Fortran program consists of several components:
Here's an example of a simple Fortran program:
program hello
! This is a comment
print *, "Hello, World!"
end program hello
This program prints "Hello, World!" to the standard output.
In Fortran, variables are used to store data that can be manipulated or accessed within a program. Each variable has a name, a data type, and a value. Variable names must adhere to certain rules, such as starting with a letter and not exceeding a certain length.
Fortran supports various data types for representing different kinds of data, including:
Additionally, Fortran provides derived data types for creating user-defined data structures.
Fortran provides various methods for reading input from the user or external sources:
READ statement: Reads input from a specified unit, such as the keyboard or a file.READ(*) statement: Reads input from the standard input (usually the keyboard).READ(*,*) statement: Reads formatted input from the standard input.READ(unit, format) statement: Reads formatted input from a specified unit.Similarly, Fortran offers several methods for displaying output to the user or external destinations:
PRINT statement: Writes output to a specified unit, such as the console or a file.WRITE statement: Writes output to a specified unit with optional formatting.PRINT *, and WRITE(*,*) statements: Write output to the standard output.FORMAT statement: Defines formatting specifications for output.Here's an example of writing and reading input:
program input_output
implicit none
integer :: num
print *, 'Enter a number:'
read(*, *) num
print *, 'You entered:', num
end program input_output
This program prompts the user to enter a number, reads the input, and then prints the entered number back to the user.
Fortran supports standard arithmetic operations for performing calculations:
Additionally, Fortran provides mathematical functions for more complex calculations, such as trigonometric functions, logarithms, and exponentials.
Arithmetic expressions in Fortran are constructed using variables, literals, arithmetic operators, and mathematical functions:
program arithmetic_expressions
implicit none
real :: a, b, result
a = 5.0
b = 3.0
result = sqrt(a**2 + b**2) ! Calculates the square root of a^2 + b^2
print *, 'Result:', result
end program arithmetic_expressions
This program calculates the square root of the sum of the squares of two numbers (a and b) using the sqrt function.
The IF statement in Fortran allows conditional execution of code based on the evaluation of a logical expression:
program if_statement
implicit none
integer :: x
print *, 'Enter a number:'
read(*, *) x
if (x > 0) then
print *, 'Positive'
else if (x < 0) then
print *, 'Negative'
else
print *, 'Zero'
end if
end program if_statement
This program prompts the user to enter a number and then determines whether it's positive, negative, or zero using the IF statement.
The DO loop in Fortran allows iterative execution of code a specified number of times:
program do_loop
implicit none
integer :: i
print *, 'Counting from 1 to 5:'
do i = 1, 5
print *, i
end do
end program do_loop
This program uses a DO loop to count from 1 to 5 and print each number.
The SELECT CASE statement in Fortran allows conditional branching based on the value of an expression:
program select_case
implicit none
integer :: day
print *, 'Enter a day (1-7):'
read(*, *) day
select case(day)
case(1)
print *, 'Sunday'
case(2)
print *, 'Monday'
case(3)
print *, 'Tuesday'
case(4)
print *, 'Wednesday'
case(5)
print *, 'Thursday'
case(6)
print *, 'Friday'
case(7)
print *, 'Saturday'
case default
print *, 'Invalid day'
end select
end program select_case
This program prompts the user to enter a day number and then prints the corresponding day of the week using a SELECT CASE statement.
Arrays in Fortran are collections of elements of the same data type that are stored in contiguous memory locations. They allow efficient storage and manipulation of data, especially when dealing with large sets of similar data.
Fortran provides various array operations for performing calculations and manipulations on arrays:
Here's an example of performing an element-wise operation on arrays:
program array_operations
implicit none
integer :: i
real :: a(3), b(3), result(3)
a = [1.0, 2.0, 3.0]
b = [4.0, 5.0, 6.0]
result = a + b ! Element-wise addition
do i = 1, 3
print *, result(i)
end do
end program array_operations
This program adds corresponding elements of two arrays (a and b) and prints the result.
Subroutines in Fortran are reusable blocks of code that perform specific tasks. They allow you to modularize your code by separating different functionalities into smaller, more manageable units. Subroutines can accept input parameters and return values, but they cannot be called recursively.
Functions in Fortran are similar to subroutines but are specifically designed to return a single value. They are useful for encapsulating algorithms or computations that produce a result. Functions can accept input parameters, perform calculations, and return a result to the calling code.
Here's an example of a subroutine and a function:
module example_mod
implicit none
contains
subroutine my_subroutine(x)
real, intent(in) :: x
print *, 'Inside subroutine:', x
end subroutine my_subroutine
function my_function(x, y)
real :: my_function
real, intent(in) :: x, y
my_function = x**2 + y**2
end function my_function
end module example_mod
program subroutine_function_example
use example_mod
implicit none
real :: a, b, result
a = 3.0
b = 4.0
call my_subroutine(a)
result = my_function(a, b)
print *, 'Result from function:', result
end program subroutine_function_example
This program demonstrates the usage of a subroutine (my_subroutine) and a function (my_function) to perform specific tasks.
Modules in Fortran are used to organize related procedures, data, and variables into reusable units. They provide a way to encapsulate and modularize code, making it easier to manage and maintain large projects. Modules can contain subroutines, functions, data types, and variable declarations.
Modules help in organizing Fortran programs by:
Here's an example of using a module to organize code:
module math_operations
implicit none
contains
function square(x)
real :: square
real, intent(in) :: x
square = x**2
end function square
function cube(x)
real :: cube
real, intent(in) :: x
cube = x**3
end function cube
end module math_operations
program program_organization_example
use math_operations
implicit none
real :: result1, result2
result1 = square(2.0)
result2 = cube(3.0)
print *, 'Square:', result1
print *, 'Cube:', result2
end program program_organization_example
This program demonstrates the use of a module (math_operations) to organize mathematical operations such as squaring and cubing.
Fortran provides built-in functionalities for reading from and writing to files. File input/output (I/O) operations allow you to interact with external files, such as text files, binary files, or standard input/output streams.
Here are some common file I/O operations in Fortran:
READ statement)WRITE statement)Here's an example of reading data from a file and writing the contents to the standard output:
program file_handling_example
implicit none
integer :: unit, i
real :: data
character(len=100) :: filename
print *, 'Enter the filename:'
read(*, *) filename
open(unit, file=trim(filename), status='old', action='read')
do i = 1, 10
read(unit, *) data
print *, 'Data:', data
end do
close(unit)
end program file_handling_example
This program prompts the user to enter a filename, reads the data from the file, and then prints the data to the standard output.
Object-Oriented Programming (OOP) is a programming paradigm that focuses on the concept of objects, which can contain data and methods. Fortran supports OOP features through modules and derived types. With OOP in Fortran, you can create user-defined data types, encapsulate data and procedures, and achieve better code organization and reusability.
Fortran can be interfaced with other languages, such as C and C++, to leverage libraries and functionalities written in those languages. Interfacing can be achieved through various methods, including:
Parallel programming in Fortran allows you to leverage multiple processing units (e.g., CPU cores, GPUs) to improve performance and efficiency. Fortran provides several methods for parallel programming, including:
Here's an example of using OpenMP for parallel programming:
program parallel_hello
implicit none
integer :: i, tid, num_threads
!$OMP PARALLEL PRIVATE(tid)
tid = omp_get_thread_num()
num_threads = omp_get_num_threads()
print *, 'Hello from thread', tid, 'of', num_threads
!$OMP END PARALLEL
end program parallel_hello
This program prints a message from each parallel thread using OpenMP directives.
Fortran is well-suited for numerical methods and scientific computing due to its efficiency and extensive standard library for mathematical functions. Numerical methods such as solving differential equations, linear algebra computations, optimization, and simulation can be implemented effectively in Fortran. Additionally, Fortran libraries such as LAPACK and BLAS provide optimized routines for numerical computations.
Fortran has undergone several revisions and updates since its inception. Some of the key Fortran standards include Fortran 77, Fortran 90, Fortran 95, Fortran 2003, Fortran 2008, and Fortran 2018. Each new standard introduced new features, improvements, and enhancements to the language, such as support for modern programming constructs, better error handling, and increased interoperability with other languages.